home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume20 / notation / part04 < prev    next >
Encoding:
Text File  |  1991-06-18  |  43.8 KB  |  1,860 lines
  1. Newsgroups: comp.sources.misc
  2. From: Henry Thomas <hthomas@irisa.fr>
  3. Subject:  v20i055:  notation - chess text handler, Part04/04
  4. Message-ID: <1991Jun17.051704.2793@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 6d45e78820426a7440322c07db224a7f
  6. Date: Mon, 17 Jun 1991 05:17:04 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: Henry Thomas <hthomas@irisa.fr>
  10. Posting-number: Volume 20, Issue 55
  11. Archive-name: notation/part04
  12. Supersedes: notation: Volume 18, Issue 12-14
  13.  
  14. #! /bin/sh
  15. # This is a shell archive.  Remove anything before this line, then unpack
  16. # it by saving it into a file and typing "sh file".  To overwrite existing
  17. # files, type "sh file -c".  You can also feed this as standard input via
  18. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  19. # will see the following message at the end:
  20. #        "End of archive 4 (of 4)."
  21. # Contents:  notation.c
  22. # Wrapped by hthomas@cattus on Sun Jun 16 18:17:28 1991
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. if test -f 'notation.c' -a "${1}" != "-c" ; then 
  25.   echo shar: Will not clobber existing file \"'notation.c'\"
  26. else
  27. echo shar: Extracting \"'notation.c'\" \(40751 characters\)
  28. sed "s/^X//" >'notation.c' <<'END_OF_FILE'
  29. X/*
  30. X  Notation program
  31. X  @(#)notation.c    3.1 (C) Henry Thomas\tVersion 3.1\tDated 6/16/91
  32. X */
  33. X/* Programme d'analyse de notation echiquienne
  34. X   Copyright (C) 1990 Henry Thomas
  35. X   Nom: notation
  36. X   Auteur: Henry Thomas
  37. X   Date: 27/11/90
  38. X/*
  39. XThis file is part of NOTATION program.
  40. X
  41. XNOTATION is free software; you can redistribute it and/or modify
  42. Xit under the terms of the GNU General Public License as published by
  43. Xthe Free Software Foundation; either version 1, or (at your option)
  44. Xany later version.
  45. X
  46. XNOTATION is distributed in the hope that it will be useful,
  47. Xbut WITHOUT ANY WARRANTY; without even the implied warranty of
  48. XMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  49. XGNU General Public License for more details.
  50. X
  51. XYou should have received a copy of the GNU General Public License
  52. Xalong with NOTATION; see the file COPYING.  If not, write to
  53. Xthe Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  54. X
  55. X/* --------------------- data part ---------------------- */
  56. X
  57. X/* les tableaux suivants sont les tables de transcription de notation
  58. X   selon les langages
  59. X   */
  60. X#ifdef __STDC__
  61. X#include <stdlib.h>
  62. X#endif
  63. X#include <stdio.h>
  64. X#include <string.h>
  65. X#include <ctype.h>
  66. X
  67. X#include "chesstype.h"
  68. X#include "notation.h"
  69. X#include "drivers.h"
  70. X#include "lexer.h"
  71. X
  72. Xextern void close_files();
  73. X
  74. Xchar * version_string =
  75. X  "@(#)notation.c    3.1 (C) Henry Thomas\tVersion 3.1\tDated 6/16/91";
  76. X
  77. Xstatic char * keywords[]= {
  78. X  "@startplay" , "@clearboard" , "@showboard" ,
  79. X  "@whitesmove", "@blacksmove", "@configwhite", "@configblack" ,
  80. X  "@default" , 
  81. X  /* these are keywords with arguments */
  82. X  "@title", "@subtitle", "@score", "@language",
  83. X  /* "special" keyword */
  84. X  "@special", 
  85. X  /* null and final keyword */
  86. X  "@null"
  87. X  };
  88. X
  89. Xint configuring = FALSE ;
  90. Xint configside = 0 ;
  91. X
  92. X
  93. Xstatic char * t_language[] = {
  94. X  "french", "english", "italian", "spanish", "german", "dutch",
  95. X  "czech",  "hungarian","polish", "romanian", "FIDE"
  96. X};
  97. X
  98. Xstatic int in_language = DEFAULT_INPUT_LANGUAGE ;
  99. Xstatic int out_language = DEFAULT_OUTPUT_LANGUAGE ;
  100. X
  101. Xstatic char c_language[NBLANGUAGES][7] = {
  102. X/* french    */  { '@' ,'R' , 'D' , 'T' , 'F' , 'C' , 'P' },
  103. X/* english   */  { '@' ,'K' , 'Q' , 'R' , 'B' , 'N' , 'P' },
  104. X/* italian   */  { '@' ,'R' , 'D' , 'T' , 'A' , 'C' , 'P' },
  105. X/* spanish   */  { '@' ,'R' , 'D' , 'T' , 'A' , 'C' , 'P' },
  106. X/* german    */  { '@' ,'K' , 'D' , 'T' , 'L' , 'S' , 'B' },
  107. X/* dutch     */  { '@' ,'K' , 'D' , 'T' , 'L' , 'P' , 'O' },
  108. X/* czech     */  { '@' ,'K' , 'D' , 'V' , 'S' , 'J' , 'P' },
  109. X/* hungarian */  { '@' ,'K' , 'V' , 'B' , 'F' , 'H' , 'G' },
  110. X/* polish    */  { '@' ,'K' , 'H' , 'W' , 'G' , 'S' , 'P' },
  111. X/* romanian  */  { '@' ,'R' , 'D' , 'T' , 'N' , 'C' , 'P' },
  112. X/* FIDE      */  { '@' ,'K' , 'D' , 'T' , 'S' , 'N' , 'P' }
  113. X/* UNIMPLEMENTED ... */
  114. X/* user_def  *//*{ '@' ,'X' , 'X' , 'X' , 'X' , 'X' , 'X' }*/
  115. X/* russian not implemented : ASCII russian is an oxymoron */
  116. X/* russian   *//*{ '@' ,'K' , 'F' , 'D' , 'C' , 'K' , 'P' }*/
  117. X           };
  118. X
  119. X/* input translation table */
  120. Xchar *in_table;
  121. X 
  122. X
  123. Xchar *  c_roque[] = { "O-O" , "O-O-O" , "o-o" , "o-o-o" , "0-0" , "0-0-0" };
  124. X
  125. X/* various notations for en passant */
  126. X#define N_EP 2
  127. Xchar * c_en_passant[] = { "ep" , "e.p." } ;
  128. X
  129. X
  130. X/* notation for catch */
  131. Xchar c_prise ='x';
  132. X
  133. X/* various comments */
  134. Xchar * c_comments[] = { "+" , "++" , 
  135. X              "?" , "??", "!", "!!", "!?", "?!",
  136. X              "mate", "draw" };
  137. X
  138. X/* movement tables */
  139. X/* move only */
  140. X/* white pawn, move */
  141. X#define NB_M_PAWN_MOVE_WD 2
  142. Xstatic int m_pawn_move_wd [][2] = {
  143. X  { 1, 0}, {2, 0}
  144. X};
  145. X
  146. X/* black pawn, move */
  147. X#define NB_M_PAWN_MOVE_BD 2
  148. Xstatic int m_pawn_move_bd [][2] = {
  149. X  {-1, 0}, {-2, 0}
  150. X};
  151. X
  152. X/* TRICK = we have added the catching move at the end of
  153. X   the non catching ones; so in check_depl, we try first 
  154. X   the non catching one and then the catching one.
  155. X   So, even if catching (x) is non indicated in the input, 
  156. X   we succeed in guessing the move
  157. X   */
  158. X/* white pawn, move */
  159. X/*#define NB_M_PAWN_WD 2*/
  160. X#define NB_M_PAWN_WD 4
  161. Xstatic int m_pawn_wd [][2] = {
  162. X  { 1, 0}, {2, 0},
  163. X/* catch... */
  164. X  { 1, 1}, { 1,-1}
  165. X};
  166. X
  167. X/* white pawn, catch */
  168. X#define NB_M_PAWN_WX 2
  169. Xstatic int m_pawn_wx [][2] = {
  170. X  { 1, 1}, { 1,-1}
  171. X};
  172. X
  173. X/* black pawn, move */
  174. X/*#define NB_M_PAWN_BD 2*/
  175. X#define NB_M_PAWN_BD 4
  176. Xstatic int m_pawn_bd [][2] = {
  177. X  {-1, 0}, {-2, 0},
  178. X/* catch... */
  179. X  {-1, 1}, {-1,-1} 
  180. X};
  181. X
  182. X/* black pawn, catch */
  183. X#define NB_M_PAWN_BX 2
  184. Xstatic int m_pawn_bx [][2] = {
  185. X  {-1, 1}, {-1,-1} 
  186. X};
  187. X
  188. X
  189. X#define NB_M_KNIGHT  8
  190. Xstatic int m_knight[][2] = { 
  191. X  { 2, 1}, { 2,-1}, {-2, 1}, {-2,-1},
  192. X  { 1, 2}, { 1,-2}, {-1, 2}, {-1,-2}
  193. X};
  194. X
  195. X#define NB_M_BISHOP 28
  196. Xstatic int m_bishop[][2] = {
  197. X  { 7, 7},  {6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
  198. X  { 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
  199. X  {-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
  200. X  {-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1}
  201. X};
  202. X
  203. X#define NB_M_ROOK 28
  204. Xstatic int m_rook[][2] = {
  205. X  { 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
  206. X  {-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
  207. X  { 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
  208. X  { 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
  209. X};
  210. X
  211. X#define NB_M_QUEEN 56
  212. Xstatic int m_queen[][2] = {
  213. X  { 7, 7},  {6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
  214. X  { 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
  215. X  {-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
  216. X  {-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1},
  217. X  { 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
  218. X  {-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
  219. X  { 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
  220. X  { 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
  221. X};
  222. X
  223. X#define NB_M_KING 8
  224. Xstatic int m_king[][2] = {
  225. X  { 1, 1}, { 1, 0}, { 1,-1},
  226. X  {-1, 1}, {-1, 0}, {-1,-1},
  227. X  { 0, 1}, { 0, -1}
  228. X};
  229. X
  230. X
  231. X/* I/O */
  232. XFILE * infile ;
  233. XFILE * fhelp;
  234. X
  235. Xstatic char * t_output[] = 
  236. X{ "ascii", "postscript", "tex", "roff", "xchess", "gnu" };
  237. X
  238. X/* stack -- used for variation */
  239. X
  240. X/* stack element */
  241. Xtypedef struct {
  242. X  depl * d;
  243. X  game * b;
  244. X  
  245. X  /* we don't stack drivers, but only to variables */
  246. X  int d1,d2; /* iswhiteturn and interrupt */
  247. X} stack_elt ;
  248. X
  249. X/* size of the stack
  250. X   0 = ordinary play
  251. X   1 = level 1 variation
  252. X   2 = level 2 variation
  253. X   3 = level 3 variation
  254. X*/
  255. X#define VARIATION_MAX 3
  256. X
  257. X/* the stack itself */
  258. Xstatic stack_elt stack[VARIATION_MAX];
  259. X
  260. X/* top of the stack */
  261. X/* --> explicit in dr->variation */
  262. X
  263. X
  264. X/* ---------- automata definitions --------- */
  265. X/* table for syntaxic analysis of move */
  266. X
  267. X#define FINAL    10
  268. X#define TML     FINAL   /* terminal state */
  269. X#define NBETAT     11
  270. X#define NBCLAS     8
  271. X
  272. X/* successor of state */
  273. Xstatic int transit[NBETAT][NBCLAS] = { 
  274. X/*   P a-h 1-8   -   x   =  \0   ? */ 
  275. X/*(  0   1   2   3   4   5   6   7)*/
  276. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  0 */
  277. X  { -1,  2, -1, -1,  4, -1, -1, -1 }, /* etat  1 */
  278. X  { -1,  6,  3,  4,  4,  8,TML,TML }, /* etat  2 */
  279. X  { -1,  6, -1,  4,  4,  8,TML,TML }, /* etat  3 */
  280. X  {  5,  6, -1, -1, -1, -1, -1, -1 }, /* etat  4 */
  281. X  { -1,  6, -1, -1, -1, -1, -1, -1 }, /* etat  5 */
  282. X  { -1, -1,  7, -1, -1, -1, -1, -1 }, /* etat  6 */
  283. X  { -1, -1, -1, -1, -1,  8,TML,TML }, /* etat  7 */
  284. X  {  9, -1, -1, -1, -1, -1, -1, -1 }, /* etat  8 */
  285. X  { -1, -1, -1, -1, -1, -1,TML,TML }, /* etat  9 */
  286. X  { -1, -1, -1, -1, -1, -1, -1, -1 }  /* etat 10 == terminal */
  287. X};
  288. X
  289. X/* actions to do */
  290. Xstatic int action[NBETAT][NBCLAS] = {
  291. X/*   P a-h 1-8   -   x   =  \0   ? */ 
  292. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  0 */
  293. X  { -1,  2, -1, -1, 10, -1, -1, -1 }, /* etat  1 */
  294. X  { -1, 13,  3,  4,  5, 14,  6,  7 }, /* etat  2 */
  295. X  { -1, 13, -1,  4,  5, 14,  6,  7 }, /* etat  3 */
  296. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  4 */
  297. X  { -1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  5 */
  298. X  { -1, -1,  3, -1, -1, -1, -1, -1 }, /* etat  6 */
  299. X  { -1, -1, -1, -1, -1, 14,  8,  9 }, /* etat  7 */
  300. X  { 15, -1, -1, -1, -1, -1, -1, -1 }, /* etat  8 */
  301. X  { -1, -1, -1, -1, -1, -1, 17, 17 }, /* etat  9 */
  302. X  { -1, -1, -1, -1, -1, -1, -1, -1 }  /* etat 10 */
  303. X};
  304. X
  305. X
  306. X/* the complete play */
  307. Xplay * theplay ;
  308. X
  309. X/* current game
  310. X   the name "tos" means "top of stack"
  311. X   */
  312. Xstatic game * tos = GULL ;
  313. X
  314. X/* variable holding current move */
  315. Xstatic depl * m = MULL ;
  316. X
  317. X/* the output driver */
  318. Xstatic format * dr;
  319. X
  320. Xstatic int driver; /* driver type, ie gnu, ascii ... */
  321. X
  322. Xstatic int movecount;
  323. X
  324. X/* current move, used by the parser */
  325. Xstatic int curpiece,  curcol,  curlig ;
  326. Xstatic int curdigit, curmove;
  327. X
  328. X/* booleen d'erreur */
  329. Xint error_flag = FALSE;
  330. X
  331. X/* move to display board */
  332. Xstatic int count = 0 ;
  333. X
  334. Xstatic int move_to_display[NB_MOVE_TO_DISP] ;
  335. Xstatic int nb_move_to_dsp = 0;
  336. Xstatic int stop_at_display = FALSE;
  337. X
  338. X/* short and long form comment table */
  339. Xchar * com_short[] = {
  340. X#define CHESSSYMB(LET,LASC,SASC,TEX,PS,ENG,FRA) SASC,
  341. X#include "chesssymb.def"
  342. X ""
  343. X };
  344. X#undef CHESSSYMB
  345. X
  346. Xchar * com_long[] = {
  347. X#define CHESSSYMB(LET,LASC,SASC,TEX,PS,ENG,FRA) LASC,
  348. X#include "chesssymb.def"
  349. X ""
  350. X };
  351. X#undef CHESSSYMB
  352. X
  353. X
  354. X
  355. X#define setboard(A,I,J,P,C)  { (A)->board[(I)][(J)] = (P) ; \
  356. X                 (A)->color[(I)][(J)] = (C); }
  357. X#define clsboard(A,I,J)   { (A)->board[(I)][(J)] = VOID ; \
  358. X                (A)->color[(I)][(J)] = VOID ;}
  359. X
  360. X/* --------------------------- code part --------------------- */
  361. X
  362. X
  363. X#ifdef __STDC__
  364. Xstatic int ispiece(char c)
  365. X#else
  366. Xstatic int ispiece(c)
  367. X     char c;
  368. X#endif
  369. X{
  370. X  register int i;
  371. X  
  372. X  for ( i = 0 ; (i < NUMPIECES) && (c != in_table[i]) ; i++ ) ;
  373. X  /*(void) fprintf(stdout, "piece %d %c\n" , i , c);*/
  374. X  return(i<NUMPIECES);
  375. X}
  376. X
  377. X
  378. X#ifdef __STDC__
  379. Xstatic int piece(char c)
  380. X#else
  381. Xstatic int piece(c)
  382. X     char c ;
  383. X#endif
  384. X{
  385. X  register int i;
  386. X  
  387. X  for ( i = 0 ; (i < NUMPIECES) && (c != in_table[i]) ; i++ ) ;
  388. X  if ( i== NUMPIECES)
  389. X    i = PAWN ;
  390. X  return(i);
  391. X}
  392. X
  393. X/* this function return yhe # entry of a keyword in a given table.
  394. X   if key is not present, it returns the default value
  395. X   */
  396. X#ifdef __STDC__
  397. Xstatic int find_keyword(char *tab[], int nbentry,int defaut,
  398. X            char *key,int warning)
  399. X#else
  400. Xstatic int find_keyword(tab, nbentry,defaut,key,warning)
  401. X     char * tab[]; /* the table to look in */
  402. X     int nbentry;  /* number of entries */
  403. X     int defaut;  /* the default value to return if search failed */
  404. X     char *key;    /* the key to find */
  405. X     int warning;  /* do we display a warning ? */
  406. X#endif
  407. X{
  408. X  int i ;
  409. X
  410. X  for(i=0; (i< nbentry) ;i++)
  411. X    if (strcmp(tab[i],key)==0)
  412. X      return(i);
  413. X
  414. X  /* we failed to find the keyword */
  415. X  if (warning)
  416. X    (void) fprintf (stderr, "unknow keyword %s in this context\n",key);
  417. X  return(defaut);
  418. X}
  419. X
  420. X/* ---------- board management function ------------- */
  421. X
  422. X#ifdef __STDC__
  423. Xvoid clear_board(game *g)
  424. X#else
  425. Xvoid clear_board(g)
  426. X     game *g;
  427. X#endif
  428. X{
  429. X  register int i,j;
  430. X
  431. X  for (i=0; i < 10; i++ )
  432. X    for (j=0 ; j< 10 ; j++) {
  433. X      g->board[i][j] = VOID;
  434. X      g->color[i][j] = VOID;
  435. X    }
  436. X}
  437. X
  438. X#ifdef __STDC__
  439. Xgame * new_board(void)
  440. X#else
  441. Xgame * new_board()
  442. X#endif
  443. X{
  444. X  game * tmp;
  445. X  int i; 
  446. X
  447. X  tmp = (game *) malloc (sizeof(game));
  448. X  ALLOCP(tmp);
  449. X  for (i=0; i < ((sizeof (game))/ sizeof (int)) ; i++)
  450. X    ((int *) tmp)[i] = 0;
  451. X  return(tmp);
  452. X}
  453. X
  454. X#ifdef __STDC__
  455. Xgame * copy_board(game *from, game *to)
  456. X#else
  457. Xgame * copy_board(from, to)
  458. X     game * from;
  459. X     game * to;
  460. X#endif
  461. X{
  462. X  int i; 
  463. X
  464. X  for (i=0; i < ((sizeof (game))/ sizeof (int)) ; i++)
  465. X    ((int *) to)[i] =  ((int *) from)[i] ;
  466. X  return(to);
  467. X}
  468. X
  469. X#ifdef __STDC__
  470. Xvoid init_board(game *tgm)
  471. X#else
  472. Xvoid init_board(tgm)
  473. X  game * tgm;
  474. X#endif
  475. X{
  476. X  register int i,j;
  477. X
  478. X  clear_board(tgm);
  479. X
  480. X  for (i=1; i< 9 ; i=i+7) {
  481. X    tgm->board[i][1]= tgm->board[i][8] = ROOK ;
  482. X    tgm->board[i][2]= tgm->board[i][7] = KNIGHT ;
  483. X    tgm->board[i][3]= tgm->board[i][6] = BISHOP ;
  484. X    tgm->board[i][4]= QUEEN;
  485. X    tgm->board[i][5]= KING;
  486. X  }
  487. X  for (i=2; i< 8 ; i=i+5) 
  488. X    for (j=1; j <=8 ; j++)
  489. X      tgm->board[i][j] = PAWN;
  490. X
  491. X  for (i=1; i <=2; i++)
  492. X    for (j=1; j <=8 ; j++) {
  493. X      tgm->color[i][j] = WHITE;
  494. X      tgm->color[i+6][j] = BLACK ;
  495. X    }
  496. X}
  497. X
  498. X#ifdef __STDC__
  499. Xdepl * new_move(void)
  500. X#else
  501. Xdepl * new_move()
  502. X#endif
  503. X{
  504. X  depl * tmp;
  505. X  int i; 
  506. X  static int counter = 0;
  507. X
  508. X  tmp = (depl *) malloc (sizeof(depl));
  509. X  ALLOCP(tmp);
  510. X  for (i=0; i < ((sizeof (depl))/ sizeof (int)) ; i++)
  511. X    ((int *) tmp)[i] = 0;
  512. X  tmp->uid = ++counter;
  513. X  tmp->whiteturn = FALSE;
  514. X  tmp->move = 0;
  515. X  return(tmp);
  516. X}
  517. X
  518. X
  519. X#ifdef __STDC__
  520. Xvoid init_move(depl *m)
  521. X#else
  522. Xvoid init_move(m)
  523. X     depl *m;
  524. X#endif
  525. X{
  526. X  m->move= 1 ;
  527. X  m->whiteturn = TRUE ;
  528. X}
  529. X
  530. X#ifdef __STDC__
  531. Xdepl * copy_move(depl *from,depl *to)
  532. X#else
  533. Xdepl * copy_move(from,to)
  534. X     depl * from;
  535. X     depl * to ;
  536. X#endif
  537. X{
  538. X  int i; 
  539. X
  540. X  for (i=0; i < ((sizeof (depl))/ sizeof (int)) ; i++)
  541. X    ((int *) to)[i] = ((int *) from)[i];
  542. X
  543. X  return(to);
  544. X}
  545. X
  546. X/* add a new move as successor to the move m */
  547. X#ifdef __STDC__
  548. Xdepl * add_trailing_move(depl *mo)
  549. X#else
  550. Xdepl * add_trailing_move(mo)
  551. X     depl * mo;
  552. X#endif
  553. X{
  554. X  mo->next = new_move();
  555. X
  556. X  mo->next->prev = mo;
  557. X  mo->next->next = (depl *) NULL;
  558. X  mo->next->sub  = (depl *) NULL;
  559. X
  560. X  mo->next->whiteturn = !( m->whiteturn ) ;
  561. X  mo->next->move = mo->move;
  562. X  if ( mo->next->whiteturn) {
  563. X    mo->next->move++;
  564. X  }
  565. X
  566. X  return(mo->next);
  567. X}
  568. X
  569. X#ifdef __STDC__
  570. Xstatic depl * add_variation(depl *mo)
  571. X#else
  572. Xstatic depl * add_variation(mo)
  573. X     depl * mo;
  574. X#endif
  575. X{
  576. X  depl *ip ; /* insertion point */
  577. X
  578. X  ip = mo ;
  579. X  while (ip->sub != (depl *) NULL )
  580. X    ip = ip->sub ;
  581. X  
  582. X  ip->sub = new_move();
  583. X
  584. X  ip->sub->prev = mo;
  585. X  ip->sub->next = (depl *) NULL;
  586. X  ip->sub->sub  = (depl *) NULL;
  587. X  
  588. X  /* as we have a fictif element heading our list, 
  589. X     ( generated by add_trailing_move() )
  590. X     we have to go back in the numbering */
  591. X  ip->sub->whiteturn =  mo->prev->whiteturn  ;
  592. X  ip->sub->move = mo->prev->move ;
  593. X
  594. X  return(ip->sub);
  595. X}
  596. X
  597. X
  598. X#ifdef __STDC__
  599. Xstatic void free_move_list(depl *d)
  600. X#else
  601. Xstatic void free_move_list(d)
  602. X     depl * d;
  603. X#endif
  604. X{  
  605. X
  606. X  if (d->next != (depl *) NULL) {
  607. X    free_move_list(d->next);
  608. X    free(d->next);
  609. X    d->next = (depl *) NULL;
  610. X  }
  611. X  if (d->sub != (depl *) NULL) {
  612. X    free_move_list(d->sub);
  613. X    free(d->sub);
  614. X    d->sub = (depl *) NULL;
  615. X  }
  616. X}
  617. X  
  618. X/* this procedure undo the effect of move m on the board g */
  619. X#ifdef __STDC__
  620. Xstatic void undo_move(game *g,depl *m)
  621. X#else
  622. Xstatic void undo_move(g,m)
  623. X     game *g;
  624. X     depl *m;
  625. X#endif
  626. X{
  627. X  int lig;
  628. X  if (m->whiteturn)
  629. X    lig = 1;
  630. X  else 
  631. X    lig = 8;
  632. X  switch (m->type) {
  633. X  case MOVE:
  634. X    clsboard(g,m->tolig,m->tocol) ;
  635. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  636. X    break;
  637. X  case PRISE:
  638. X    setboard(g,m->tolig,m->tocol,m->prise,OPPCOLOR(m)) ;
  639. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  640. X    break;
  641. X  case GRANDROQUE:
  642. X    clsboard(g,lig,3) ;
  643. X    clsboard(g,lig,3) ;
  644. X    setboard(g,m->fromlig,5,KING,CURCOLOR(m)) ;
  645. X    setboard(g,m->fromlig,5,ROOK,CURCOLOR(m)) ;
  646. X    break;
  647. X  case PETITROQUE:
  648. X    clsboard(g,lig,6) ;
  649. X    clsboard(g,lig,7) ;
  650. X    setboard(g,m->fromlig,5,KING,CURCOLOR(m)) ;
  651. X    setboard(g,m->fromlig,8,ROOK,CURCOLOR(m)) ;
  652. X    break;
  653. X  case EN_PASSANT:
  654. X    clsboard(g,m->tolig,m->tocol) ;
  655. X    setboard(g,m->tolig,m->fromcol,PAWN,OPPCOLOR(m)) ;
  656. X
  657. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  658. X    break;
  659. X  case PROMOTION:
  660. X    clsboard(g,m->tolig,m->tocol);
  661. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  662. X    break;
  663. X  case PROM_ET_PRISE:
  664. X    setboard(g,m->tolig,m->tocol,m->prise,OPPCOLOR(m)) ;
  665. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  666. X    break;
  667. X  default:
  668. X    fprintf(stderr,"unable to undo move: unknown move type\n");
  669. X    break;
  670. X  }
  671. X}
  672. X
  673. X/* variation procedures == stack manipulation */
  674. X
  675. X#ifdef __STDC__
  676. Xvoid enter_variation(void)
  677. X#else
  678. Xvoid enter_variation()
  679. X#endif
  680. X{
  681. X  int l;
  682. X
  683. X  l = dr->variation ;
  684. X  
  685. X  if (l >= VARIATION_MAX) {
  686. X    error((stderr,"Maximum imbricated variation is %d",VARIATION_MAX));
  687. X  } else {
  688. X    /* save current line/variation */
  689. X    stack[l].d = m;
  690. X    stack[l].b = tos;
  691. X    stack[l].d1 = dr->iswhiteturn;
  692. X    stack[l].d2 = dr->interrupt = TRUE ;    
  693. X    /* create new */
  694. X    tos = new_board();
  695. X    (void) copy_board(stack[l].b, tos);
  696. X
  697. X    /* A variation FOLLOWS the main line 
  698. X       so we need to backtrack one move
  699. X       */
  700. X    m = add_variation(stack[l].d);
  701. X    undo_move(tos,stack[l].d);
  702. X
  703. X    /* set variables */
  704. X    l++;
  705. X    dr->variation = l;
  706. X
  707. X    output_variation(dr,VARIATION_IN);
  708. X  }
  709. X}
  710. X
  711. X#ifdef __STDC__
  712. Xvoid exit_variation(void)
  713. X#else
  714. Xvoid exit_variation()
  715. X#endif
  716. X{
  717. X  int l ;
  718. X
  719. X  l = dr->variation ;
  720. X  
  721. X  if (l == 0) {
  722. X    error((stderr,"You cannot exit from the main line (variation error?)"));
  723. X  } else {
  724. X    output_variation(dr,VARIATION_OUT);
  725. X
  726. X    l--;
  727. X    free(tos);
  728. X    free(m);
  729. X    m = stack[l].d ;
  730. X    tos = stack[l].b ;
  731. X
  732. X    dr->iswhiteturn = stack[l].d1 ;
  733. X    dr->interrupt = stack[l].d2 ;
  734. X    dr->variation = l;
  735. X  }
  736. X}
  737. X
  738. X/* ----------- semantic evaluation of move ----------- */
  739. X/* check if  position lies within the board
  740. X   */
  741. X#ifdef __STDC__
  742. Xint in_board(int l,int c)
  743. X#else
  744. Xint in_board(l,c)
  745. X     int l,c;
  746. X#endif
  747. X{
  748. X  return ((c >= 1) && (c <= 8) && (l >= 1) && (l <= 8));
  749. X}
  750. X
  751. X/* check that the path from pos1 to pos2 is free
  752. X   */
  753. X#ifdef __STDC__
  754. Xint path_free(int l1,int c1,int l2,int c2)
  755. X#else
  756. Xint path_free(l1, c1, l2, c2)
  757. Xint l1,c1, l2, c2;
  758. X#endif
  759. X{
  760. X  int li = 1 ;
  761. X  int ci = 1 ;
  762. X  int lig, col;
  763. X
  764. X
  765. X  li = SIGN(l2-l1);
  766. X  ci = SIGN(c2-c1);
  767. X
  768. X
  769. X  if ( c1 == c2 ) {    
  770. X    col = c1;
  771. X    for (lig = l1 +li; lig != l2 ; lig +=li)
  772. X      if (tos->board[lig][col] != VOID)
  773. X    return (FALSE);
  774. X    return(TRUE);
  775. X  }
  776. X
  777. X  if ( l1 == l2) {
  778. X    lig = l1 ;
  779. X    for (col = c1 + ci; col != c2 ; col +=ci)
  780. X      if (tos->board[lig][col] != VOID)
  781. X    return (FALSE);
  782. X    return(TRUE);
  783. X  }
  784. X
  785. X  for (lig = l1+li,col =c1+ci; (lig!=l2) && (col!=c2); lig+=li, col+= ci)
  786. X    if (tos->board[lig][col] != VOID) {
  787. X      return (FALSE);
  788. X    }
  789. X  return(TRUE);
  790. X}
  791. X
  792. X/* check roque is possible */
  793. X#ifdef __STDC__
  794. Xint check_roque(void)
  795. X#else
  796. Xint check_roque()
  797. X#endif
  798. X{
  799. X  int lig, col ;
  800. X
  801. X  if (m->whiteturn)
  802. X    lig = 1 ;
  803. X  else
  804. X    lig =8;
  805. X  if (m->type == GRANDROQUE)
  806. X    for (col = 2; col < 5 ; col++)
  807. X      if (tos->board[lig][col] != VOID)
  808. X    return(FALSE);
  809. X  if (m->type == PETITROQUE)
  810. X    for (col = 6; col < 7 ; col++)
  811. X      if (tos->board[lig][col] != VOID)
  812. X    return(FALSE);
  813. X  return(TRUE);
  814. X}
  815. X  
  816. X/* check -- or guess -- where a given piece come */
  817. X#ifdef __STDC__
  818. Xint guess_piece(void) 
  819. X#else
  820. Xint guess_piece() 
  821. X#endif
  822. X{
  823. X  return(tos->board[m->fromlig][m->fromcol]); 
  824. X}
  825. X
  826. X/* try to guess the move -- low-level function */
  827. X#ifdef __STDC__
  828. Xint guess_depl(int nb, int tab[][2],
  829. X           int * pl1, int * pc1, int l2, int c2, int path)
  830. X#else
  831. Xint guess_depl(nb, tab, pl1, pc1, l2,c2,path)
  832. X     int nb;
  833. X     int tab[][2];
  834. X     int *pl1, *pc1;
  835. X     int l2,c2;
  836. X     int path;
  837. X#endif
  838. X{
  839. X  int i;
  840. X  int c,l;
  841. X
  842. X  for (i=0; i< nb; i++ ) {
  843. X    l = l2 - tab[i][0];
  844. X    c = c2 - tab[i][1];
  845. X    if (in_board(l,c))
  846. X      if ((tos->board[l][c] == m->piece) &&
  847. X      (tos->color[l][c] == CURCOLOR(m)) &&
  848. X      ( !path || (path && path_free(l,c, l2, c2))) &&
  849. X      ( ((*pl1) == 0) || ((*pl1) == l) ) &&
  850. X      ( ((*pc1) == 0) || ((*pc1) == c) ) )
  851. X      {
  852. X    *pl1 = l;
  853. X    *pc1 = c;
  854. X    return(TRUE);
  855. X      }
  856. X  }
  857. X  return(FALSE);
  858. X}
  859. X
  860. X/* check for ambiguitey in a move
  861. X   used in ouptut function: the piece had beenm already moved and
  862. X   if we guess another move, there is an ambiguity
  863. X   */
  864. X#ifdef __STDC__
  865. Xint ambiguity(int frompiece, int l2, int c2)
  866. X#else
  867. Xint ambiguity(frompiece, l2, c2)
  868. X     int frompiece, l2, c2 ;
  869. X#endif
  870. X{
  871. X  int l1 = 0 ;
  872. X  int c1 = 0 ;
  873. X
  874. X  switch(frompiece) {
  875. X  case PAWN:
  876. X    if (m->type == PRISE) {
  877. X      if (m->whiteturn)
  878. X    return(guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE));
  879. X      else
  880. X    return(guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE));
  881. X   } else {
  882. X      if (m->whiteturn)
  883. X    return(guess_depl(NB_M_PAWN_MOVE_WD, m_pawn_move_wd, 
  884. X              &l1,&c1, l2,c2, FALSE));
  885. X      else
  886. X    return(guess_depl(NB_M_PAWN_MOVE_BD, m_pawn_move_bd, 
  887. X              &l1,&c1, l2,c2, FALSE));
  888. X    }
  889. X    /* break; */
  890. X  case KNIGHT:
  891. X    return(guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE));
  892. X    /* break; */
  893. X  case BISHOP:
  894. X    return(guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE));
  895. X    /* break; */
  896. X  case ROOK:
  897. X    return(guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE));
  898. X    /* break; */
  899. X  case QUEEN:
  900. X    return(guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE));
  901. X    /* break; */
  902. X  case KING:
  903. X    return(guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE));
  904. X    /* break; */
  905. X  default:
  906. X    break;
  907. X  }
  908. X  return(TRUE);
  909. X}
  910. X
  911. X#ifdef __STDC__
  912. Xint check_move(depl *m)
  913. X#else
  914. Xint check_move(m)
  915. X     depl * m;
  916. X#endif
  917. X{
  918. X  int l1,c1,l2,c2;
  919. X  int tmp; /* tmp boolean */
  920. X 
  921. X  l1 = m->fromlig;
  922. X  c1 = m->fromcol;
  923. X  l2 = m->tolig;
  924. X  c2 = m->tocol;
  925. X
  926. X  if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
  927. X    return(check_roque());
  928. X
  929. X  if ((tos->board[l1][c1] != m->piece)||
  930. X      (tos->color[l1][c1] != CURCOLOR(m))){
  931. X    fprintf(stderr,"hum... piece should be %d \n",tos->board[l1][c1]);
  932. X    error ((stderr,": from position and piece not coherent at move (%d,%d)\n",
  933. X        m->move,m->whiteturn));
  934. X    return(FALSE);
  935. X  }
  936. X
  937. X  /* if prise === FALSE, we must not take a piece */
  938. X  if (tos->board[l2][c2] != VOID 
  939. X      && (m->type != PRISE) && (m->type != PROM_ET_PRISE)) {
  940. X    (void) fprintf(stderr,"catching not indicated at move %d\n",m->move);
  941. X    return(FALSE);
  942. X  }
  943. X
  944. X  /* prendre une de ses propres pieces */
  945. X  if (tos->color[l2][c2] == tos->color[l1][c1] && m->prise) {
  946. X    (void) fprintf(stderr,"attempt to catch same color piece at move %d\n",
  947. X           m->move);
  948. X    return(FALSE);
  949. X  }
  950. X
  951. X  /* we check if the move is a possible one for the piece
  952. X     */
  953. X
  954. X  switch(m->piece) {
  955. X  case PAWN:
  956. X    if (m->prise) {
  957. X      if (m->whiteturn)
  958. X    tmp = guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
  959. X      else
  960. X    tmp = guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
  961. X   } else {
  962. X      if (m->whiteturn)
  963. X    tmp = guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE);
  964. X      else
  965. X    tmp = guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE);
  966. X    }
  967. X    /* is it a "prise en passant " */
  968. X    if ((c1 != c2) && (tos->board[l2][c2] == VOID)
  969. X    && (tos->board[l1][c2] == PAWN)) {
  970. X      m->type = EN_PASSANT ;
  971. X      /* we must perform here the "en passant" test */
  972. X      tos->board[l1][c2] = VOID ;
  973. X      tos->color[l1][c2] = VOID ;
  974. X      tmp = TRUE;
  975. X    }
  976. X    return(tmp);
  977. X    /* break; */
  978. X  case KNIGHT:
  979. X    return(guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE));
  980. X    /* break; */
  981. X  case BISHOP:
  982. X    return(guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE));
  983. X    /* break; */
  984. X  case ROOK:
  985. X    return(guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE));
  986. X    /* break; */
  987. X  case QUEEN:
  988. X    return(guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE));
  989. X    /* break; */
  990. X  case KING:
  991. X    return(guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE));
  992. X    /* break; */
  993. X  default:
  994. X    break;
  995. X  }
  996. X
  997. X  return(TRUE);
  998. X}
  999. X
  1000. X/* try to guess the move -- used for shortened notation
  1001. X   */
  1002. X#ifdef __STDC__
  1003. Xint guess_move(void)
  1004. X#else
  1005. Xint guess_move()
  1006. X#endif
  1007. X{
  1008. X  int l1,c1,l2,c2;
  1009. X
  1010. X  if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
  1011. X    return(TRUE);
  1012. X
  1013. X  l1 = m->fromlig ;
  1014. X  c1 = m->fromcol ;
  1015. X  l2 = m->tolig;
  1016. X  c2 = m->tocol;
  1017. X
  1018. X  switch(m->piece) {
  1019. X  case PAWN:
  1020. X    if (m->prise) {
  1021. X      if (m->whiteturn)
  1022. X    (void) guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
  1023. X      else
  1024. X    (void) guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
  1025. X    } else {
  1026. X      if (m->whiteturn)
  1027. X    (void) guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE); 
  1028. X      else
  1029. X    (void) guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE); 
  1030. X    }
  1031. X    break;
  1032. X  case KNIGHT:
  1033. X    (void) guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE);
  1034. X    break;
  1035. X  case BISHOP:
  1036. X    (void) guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE);
  1037. X    break;
  1038. X  case ROOK:
  1039. X    (void) guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE);
  1040. X    break;
  1041. X  case QUEEN:
  1042. X    (void) guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE);
  1043. X    break;
  1044. X  case KING:
  1045. X    (void) guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE);
  1046. X    break;
  1047. X  default:
  1048. X    break;
  1049. X  }
  1050. X
  1051. X  if ((l1 == 0) || (c1 == 0)) {
  1052. X    if (m->whiteturn)
  1053. X      error((stderr,"unable to guess move %d white, with piece %d\n",
  1054. X         m->move,m->piece));
  1055. X    else
  1056. X      error((stderr,"unable to guess move %d black, with piece %d\n",
  1057. X         m->move,m->piece));
  1058. X    return(FALSE);
  1059. X  } else {
  1060. X    m->fromcol = c1;
  1061. X    m->fromlig = l1;
  1062. X    return(TRUE);
  1063. X  }
  1064. X}
  1065. X
  1066. X/* --------------- execution of move ----------------- */
  1067. X
  1068. X/* clear a position */
  1069. X#ifdef __STDC__
  1070. Xint clear_pos(int lig, int col)
  1071. X#else
  1072. Xint clear_pos(lig,col)
  1073. X     int lig;
  1074. X     int col;
  1075. X#endif
  1076. X{
  1077. X  tos->board[lig][col] = VOID ;
  1078. X  tos->color[lig][col] = VOID ;
  1079. X  return(TRUE);
  1080. X}
  1081. X
  1082. X/* configure the board */
  1083. X#ifdef __STDC__
  1084. Xint configure(void)
  1085. X#else
  1086. Xint configure()
  1087. X#endif
  1088. X{
  1089. X  if (configuring) {
  1090. X    if (m->piece == VOID)
  1091. X      m->piece = PAWN ;
  1092. X    tos->board[m->tolig][m->tocol] = m->piece ;
  1093. X    tos->color[m->tolig][m->tocol] = configside ;
  1094. X  }
  1095. X  return(TRUE);
  1096. X}
  1097. X
  1098. X/* execute a move, no checking */
  1099. X#ifdef __STDC__
  1100. Xint execute_move(void)
  1101. X#else
  1102. Xint execute_move()
  1103. X#endif
  1104. X{
  1105. X  register int i;
  1106. X
  1107. X  if (m->piece == VOID )
  1108. X    m->piece = PAWN;
  1109. X
  1110. X  if ((m->fromlig == 0) || (m->fromcol == 0))
  1111. X    (void) guess_move();
  1112. X  
  1113. X  /* supply to the -- maybe -- deficiency of input notation
  1114. X     */
  1115. X  if ((m->fromlig !=0) || (m->fromcol != 0))
  1116. X    m->piece = tos->board[m->fromlig][m->fromcol];
  1117. X
  1118. X  if (tos->board[m->tolig][m->tocol] != VOID) {
  1119. X    m->type = PRISE;
  1120. X    m->prise = tos->board[m->tolig][m->tocol] ;
  1121. X  }
  1122. X
  1123. X  if (!check_move(m)) {
  1124. X    if (m->whiteturn)
  1125. X      error((stderr,"white move %d illegal\n",m->move));
  1126. X    else
  1127. X      error((stderr,"black move %d illegal\n",m->move));
  1128. X  }
  1129. X
  1130. X  if (m->type == PETITROQUE) {
  1131. X    if (m->whiteturn)
  1132. X      curlig = 1 ;
  1133. X    else
  1134. X      curlig = 8 ;
  1135. X    tos->board[curlig][7] = KING;
  1136. X    tos->board[curlig][6] = ROOK;
  1137. X    tos->color[curlig][7] = tos->color[curlig][5] ;
  1138. X    tos->color[curlig][6] = tos->color[curlig][5] ;
  1139. X    (void) clear_pos(curlig, 5);
  1140. X    (void) clear_pos(curlig, 8);
  1141. X  }
  1142. X  if (m->type == GRANDROQUE) {
  1143. X    if (m->whiteturn)
  1144. X      curlig = 1 ;
  1145. X    else
  1146. X      curlig = 8 ;
  1147. X    tos->board[curlig][3] = KING;
  1148. X    tos->board[curlig][4] = ROOK;
  1149. X    tos->color[curlig][3] = tos->color[curlig][5] ;
  1150. X    tos->color[curlig][4] = tos->color[curlig][5] ;
  1151. X    (void) clear_pos(curlig, 5);
  1152. X    (void) clear_pos(curlig, 1);
  1153. X  }
  1154. X
  1155. X        
  1156. X  if (!(m->type == GRANDROQUE) || (m->type == PETITROQUE)) {
  1157. X    if (m->piece == VOID)
  1158. X      m->piece = tos->board[m->fromlig][m->fromcol];
  1159. X    /*if (m->topiece == VOID)
  1160. X      m->topiece = tos->board[m->fromlig][m->fromcol];*/
  1161. X    tos->board[m->tolig][m->tocol] = tos->board[m->fromlig][m->fromcol];
  1162. X    tos->color[m->tolig][m->tocol] = tos->color[m->fromlig][m->fromcol];
  1163. X    (void) clear_pos(m->fromlig,m->fromcol);
  1164. X  }
  1165. X  
  1166. X  if ((m->type == PROMOTION) || (m->type == PROM_ET_PRISE))
  1167. X    tos->board[m->tolig][m->tocol] = m->promotion ;
  1168. X     
  1169. X  output_move(dr,m);
  1170. X
  1171. X  if (error_flag) {
  1172. X    (void) fprintf(dr->outfile, "\nlast position encountered:\n");
  1173. X    output_board(dr,tos);
  1174. X    close_files();
  1175. X    exit(0);
  1176. X  }
  1177. X
  1178. X  /* do we need to display the move ? */
  1179. X  if (nb_move_to_dsp > 0) {
  1180. X    for (i=0; i < nb_move_to_dsp; i++)
  1181. X      if (m->move == (move_to_display[i] ) && !m->whiteturn ) {
  1182. X    output_board(dr,tos);
  1183. X    if (stop_at_display) {
  1184. X      output_end(dr);
  1185. X      close_files();
  1186. X      exit(0);
  1187. X    }
  1188. X      }
  1189. X  }
  1190. X
  1191. X  return(TRUE);
  1192. X}
  1193. X
  1194. X/* ------------------ automata ----------------------- */
  1195. X
  1196. X/* categorise the input for the automata */
  1197. X#ifdef __STDC__
  1198. Xint typechar(char c)
  1199. X#else
  1200. Xint typechar(c)
  1201. X     char c;
  1202. X#endif
  1203. X{
  1204. X  if (ispiece(c))
  1205. X    return(0);
  1206. X  if ((c >=  'a') && ( c <= 'h'))
  1207. X    return(1);
  1208. X  if ((c >=  '1') && ( c <= '8'))
  1209. X    return(2);
  1210. X  if ( c== '-' )
  1211. X    return(3);
  1212. X  if ((c == 'x') || (c == 'X' ))
  1213. X    return(4);
  1214. X  if (c == '=' )
  1215. X    return(5);
  1216. X  if (c == '\0' )
  1217. X    return(6);
  1218. X  return(7);
  1219. X}
  1220. X
  1221. X
  1222. X/* execute the actions decided by the automata */
  1223. X#ifdef __STDC__
  1224. Xint execute(int num,char c)
  1225. X#else
  1226. Xint execute(num,c)
  1227. X     int num;
  1228. X     char c;
  1229. X#endif
  1230. X{
  1231. X  switch (num) {
  1232. X  case 1: /* set cur piece */
  1233. X    curpiece = piece(c);
  1234. X    break;
  1235. X  case 2: /* set cur col */
  1236. X    curcol = lettertocol(c);
  1237. X    break;
  1238. X  case 3: /* set cur lig */
  1239. X    curlig = lettertolig(c);
  1240. X    break;
  1241. X  case 4: /* from = cur ; prise = false */
  1242. X    m->piece = curpiece ;
  1243. X    m->fromcol = curcol ;
  1244. X    m->fromlig = curlig;
  1245. X    /*m->topiece = curpiece;*/
  1246. X    break;
  1247. X  case 5: /* from = cur ; prise = true */
  1248. X    m->piece = curpiece ;
  1249. X    m->fromcol = curcol ;
  1250. X    m->fromlig = curlig;
  1251. X    m->type = PRISE ;
  1252. X    m->prise = curpiece;
  1253. X    break;
  1254. X  case 6: /* to = cur ; guess from */
  1255. X  case 7: /* to = cur ; guess from ; parse remaining token */
  1256. X    m->piece = curpiece ;
  1257. X    m->tocol = curcol;
  1258. X    m->tolig = curlig ;
  1259. X
  1260. X    /*m->topiece = curpiece ; /* ? */
  1261. X
  1262. X    if (configuring)
  1263. X      (void) configure();
  1264. X    else {
  1265. X      (void) execute_move();
  1266. X    }
  1267. X    break;
  1268. X  case 8: /* to = cur */
  1269. X  case 9: /* to = cur */
  1270. X    m->tocol = curcol;
  1271. X    m->tolig = curlig ;
  1272. X
  1273. X    if (configuring)
  1274. X      (void) configure();
  1275. X    else {
  1276. X      (void) execute_move();
  1277. X    }
  1278. X    break;
  1279. X  case 10: /* piece = cur piece ; prise = true */
  1280. X    /* later : guess from position */
  1281. X    m->piece = curpiece ;
  1282. X    m->type = PRISE ;
  1283. X    break;
  1284. X  case 11: /* grand roque */
  1285. X  case 12: /* petit roque */
  1286. X    (void) execute_move();
  1287. X    break;
  1288. X  case 13: /* case of simpliest algebraic notation ;
  1289. X          only e2e4 : this is the transition from e2 to e4
  1290. X          also the case of move such as Nge2
  1291. X          from =cur; prise = FALSE;
  1292. X          also:
  1293. X          curcol = ...
  1294. X          */
  1295. X    m->piece = curpiece ;
  1296. X    m->fromcol = curcol ;
  1297. X    m->fromlig = curlig;
  1298. X
  1299. X    m->type = MOVE;
  1300. X    curcol = lettertocol(c);
  1301. X  case 14: /* promotion, the "=" */
  1302. X    break;
  1303. X  case 15: /* promotion, the piece name */
  1304. X    /* to = cur ; guess from */
  1305. X  case 16: 
  1306. X    /* to = cur */
  1307. X
  1308. X    m->tocol = curcol;
  1309. X    m->tolig = curlig ;
  1310. X    /*m->topiece = curpiece ;*/
  1311. X
  1312. X    if (m->type == PRISE )
  1313. X      m->type = PROM_ET_PRISE ;
  1314. X    else
  1315. X      m->type = PROMOTION ;
  1316. X    m->promotion = curpiece = piece(c) ;
  1317. X
  1318. X    break;
  1319. X  case 17: /* execute move for promotion */
  1320. X    (void) execute_move();
  1321. X    break;
  1322. X  case -1:
  1323. X    break;
  1324. X  default:
  1325. X    break;
  1326. X  }
  1327. X  return(TRUE);
  1328. X}
  1329. X
  1330. X#ifdef __STDC__
  1331. Xint parse_number(char *token)
  1332. X#else
  1333. Xint parse_number(token)
  1334. X     char *token;
  1335. X#endif
  1336. X{
  1337. X  int curmove = 0 ;
  1338. X  int i;
  1339. X
  1340. X  /* check coherency with internal numbering */
  1341. X  i = 0;
  1342. X  while (isdigit(token[i])) {
  1343. X   curmove = curmove * 10 +  ((int) token[i++] - (int) '0' );
  1344. X  }
  1345. X  movecount = curmove ;
  1346. X  return(TRUE);
  1347. X}
  1348. X
  1349. X#ifdef __STDC__
  1350. Xint parse_text(char *text)
  1351. X#else
  1352. Xint parse_text(text)
  1353. X     char *text;
  1354. X#endif
  1355. X{
  1356. X  output_text(dr,T_TEXT, text, 0);
  1357. X  return(TRUE);
  1358. X}
  1359. X
  1360. X#ifdef __STDC__
  1361. Xint parse_comment(char *com)
  1362. X#else
  1363. Xint parse_comment(com)
  1364. X     char *com;
  1365. X#endif
  1366. X{
  1367. X  int t;
  1368. X
  1369. X  if (com[0] == '$')
  1370. X    /* we look in the long ascii table */
  1371. X    t = find_keyword(com_long, NUM_COM_CODE, NUM_COM_CODE, com, TRUE);
  1372. X  else {
  1373. X    /* we look for the comment in the short ascii table */
  1374. X    t = find_keyword(com_short, NUM_COM_CODE, NUM_COM_CODE, com,FALSE);
  1375. X    if (t == NUM_COM_CODE)
  1376. X      fprintf (stderr,"\nWhat is \"%s\" ?\n",com);   
  1377. X  }
  1378. X  if (t != NUM_COM_CODE)
  1379. X    output_text(dr,T_COMMENT, com, t);
  1380. X  return(TRUE);
  1381. X}
  1382. X
  1383. X#ifdef __STDC__
  1384. Xint parse_keyword(char *token, char *text)
  1385. X#else
  1386. Xint parse_keyword(token,text)
  1387. X     char *token;
  1388. X     char *text;
  1389. X#endif
  1390. X{
  1391. X  char c;
  1392. X
  1393. X  switch (find_keyword(keywords, NBKEYWORD, KNULL, token, TRUE)) {
  1394. X  case START:
  1395. X    /* don't forget we are configuring the previous move */
  1396. X    /* -> move 0, black */
  1397. X    configuring = FALSE;
  1398. X    m->move = 0;
  1399. X    m->whiteturn = FALSE;
  1400. X    break;
  1401. X  case CLEAR:
  1402. X    clear_board(tos);
  1403. X    m= theplay->chain;
  1404. X    free_move_list(m);
  1405. X    break;
  1406. X  case SHOWBOARD:
  1407. X    output_board(dr,tos);
  1408. X    break;
  1409. X  case TOWHITE:
  1410. X    /* don't forget we are configuring the previous move */
  1411. X    /* reset to 0,black --> 1,white */
  1412. X    m->move = 0;
  1413. X    m->whiteturn = FALSE;
  1414. X    break;
  1415. X  case TOBLACK:
  1416. X    /* reset to 1,white -> 1 black */
  1417. X    m->move = 1;
  1418. X    m->whiteturn = TRUE;
  1419. X    break;
  1420. X  case CONFIGWH:
  1421. X    configuring = TRUE ;
  1422. X    configside = WHITE;
  1423. X    m= theplay->chain;
  1424. X    free_move_list(m);
  1425. X    break;
  1426. X  case CONFIGBL:
  1427. X    configuring = TRUE ;
  1428. X    configside = BLACK;
  1429. X    m= theplay->chain;
  1430. X    free_move_list(m);
  1431. X    break;
  1432. X  case DEFAULTP:
  1433. X    init_board(tos);
  1434. X    m= theplay->chain;
  1435. X    free_move_list(m);
  1436. X    break;
  1437. X  case TITLE:
  1438. X    output_text(dr, T_TITLE, text, NULL);
  1439. X    break;
  1440. X  case SUBTITLE:
  1441. X    output_text(dr, T_SUBTITLE, text, NULL);
  1442. X    break;
  1443. X  case SCORE:
  1444. X    output_text(dr, T_SCORE, text, NULL);
  1445. X    break;
  1446. X  case LANGUE:
  1447. X    in_language = find_keyword (t_language, NBLANGUAGES, in_language,
  1448. X                   text,TRUE);
  1449. X    associe_traduction( &in_table, in_language);           
  1450. X    break;
  1451. X  case SPECIAL: /* all input, up to \n is copied to output */
  1452. X    while ((( c = getc(infile)) != EOF) && (c != '\n'))
  1453. X      (void) putc (c,dr->outfile);
  1454. X    putc ('\n', dr->outfile);
  1455. X    break;
  1456. X  case KNULL:
  1457. X  default:
  1458. X    fprintf(stderr,"unknown keyword %s\n",token);
  1459. X    break;
  1460. X  }
  1461. X  return(TRUE);
  1462. X}
  1463. X
  1464. X#ifdef __STDC__
  1465. Xint parse_roque(char *token)
  1466. X#else
  1467. Xint parse_roque(token)
  1468. X     char * token;
  1469. X#endif
  1470. X{ 
  1471. X  int i;
  1472. X
  1473. X  for (i=0; i < NBROQUE && (strcmp(c_roque[i],token)!=0); i++) ;
  1474. X  if ( i < NBROQUE ) {
  1475. X    
  1476. X    m = add_trailing_move(m);
  1477. X    init_parse(m);
  1478. X
  1479. X    if (strlen(token) == 3) {
  1480. X      m->type = PETITROQUE ;
  1481. X      (void) execute(12,DUMMYCHAR);
  1482. X    } else {
  1483. X      m->type = GRANDROQUE ;
  1484. X      (void) execute(11,DUMMYCHAR);
  1485. X    }
  1486. X    /*(void) fprintf(stderr,"ROQUE\n");*/
  1487. X    return(TRUE);
  1488. X  }
  1489. X
  1490. X  return(FALSE);
  1491. X}
  1492. X
  1493. X#ifdef __STDC__
  1494. Xint  parse_move(char *token)
  1495. X#else
  1496. Xint  parse_move(token)
  1497. X     char *token;
  1498. X#endif
  1499. X{
  1500. X  register int i;
  1501. X  int correcte = FALSE ;
  1502. X  int erreursyntaxe = FALSE ;
  1503. X  int etat =0;
  1504. X  int code;
  1505. X  
  1506. X  m = add_trailing_move(m);
  1507. X  init_parse(m);
  1508. X  m->type = MOVE;
  1509. X
  1510. X  i=0;
  1511. X  while ( !correcte && !erreursyntaxe ) {
  1512. X    code = typechar(token[i]);
  1513. X    (void) execute(action[etat][code],token[i]);
  1514. X    etat = transit[etat][code] ;
  1515. X    if (etat == -1) 
  1516. X      erreursyntaxe = TRUE;
  1517. X    if (etat == FINAL)
  1518. X      correcte = TRUE ;
  1519. X    i++;
  1520. X  }
  1521. X  if (erreursyntaxe) {
  1522. X    (void) fprintf(stderr, "no comprende, senor: %s\n",token);
  1523. X    return(FALSE);
  1524. X  }
  1525. X  if (correcte) {
  1526. X    /*(void) fprintf(stderr, "ia panimaiou, davai\n");*/
  1527. X  }
  1528. X  /*init_parse(m);*/
  1529. X  return(TRUE);
  1530. X}
  1531. X
  1532. X#ifdef __STDC__
  1533. Xvoid init_parse(depl *m)
  1534. X#else
  1535. Xvoid init_parse(m)
  1536. X     depl * m ;
  1537. X#endif
  1538. X{
  1539. X
  1540. X  /* global position and piece variable initialised to 0
  1541. X     */
  1542. X  /* move and whiteturn unchanged */ 
  1543. X
  1544. X  m->type = MOVE ;
  1545. X
  1546. X  curpiece = m->piece = VOID ;
  1547. X  curcol = m->tocol = m->fromcol = 0;
  1548. X  curlig = m->tolig = m->fromlig = 0;
  1549. X
  1550. X  m->promotion = VOID;
  1551. X  m->prise = VOID;
  1552. X  m->is_check = FALSE ;
  1553. X
  1554. X  curdigit = curmove = 0;
  1555. X
  1556. X  /*if (movecount != m->move)
  1557. X    (void) fprintf(stderr,"problem in move numbering: %d vs %d\n",
  1558. X           m->move, movecount);*/
  1559. X
  1560. X}
  1561. X
  1562. X/* ------------------- top routines -------------------- */
  1563. X
  1564. X/* cette fonction analyse les arguments de la ligne de commande
  1565. X   */
  1566. X#ifdef __STDC__
  1567. Xint parse_options(int argc,char *argv[])
  1568. X#else
  1569. Xint parse_options(argc,argv)
  1570. X     int argc;
  1571. X     char * argv[];
  1572. X#endif
  1573. X{
  1574. X  int narg =1 ;
  1575. X  int i;
  1576. X  register int c;
  1577. X  char cp[132];
  1578. X  char chaine[MAXTOKLEN];
  1579. X
  1580. X  infile = stdin;
  1581. X  dr->outfile = stdout;
  1582. X  nb_move_to_dsp = 0;
  1583. X
  1584. X  while (narg < argc ) {
  1585. X    (void) strcpy (cp,argv[narg]);
  1586. X    switch (cp[0]) {
  1587. X    case '-' :
  1588. X      switch (cp[1]) {
  1589. X      case 'f' : /* from langage */
  1590. X    if  ((narg+1) >= argc )
  1591. X      fatal((stderr,"missing argument to %s option",cp));
  1592. X    narg++ ;
  1593. X    in_language = find_keyword (t_language, NBLANGUAGES,
  1594. X                    DEFAULT_INPUT_LANGUAGE,
  1595. X                    argv[narg],TRUE);
  1596. X    break;
  1597. X      case 't' : /* to langage */
  1598. X    if  ((narg+1) >= argc )
  1599. X      fatal((stderr,"missing argument to %s option",cp));
  1600. X    narg++ ;
  1601. X    out_language = find_keyword (t_language, NBLANGUAGES,
  1602. X                     DEFAULT_OUTPUT_LANGUAGE,
  1603. X                     argv[narg],TRUE);
  1604. X    break;
  1605. X      case 'o' : /* next arg is output file */
  1606. X    narg++ ;
  1607. X    if ((dr->outfile = fopen (argv[narg],"w+")) == NULL) {
  1608. X      (void) fprintf (stderr,"can't open %s output file\n",argv[narg]);
  1609. X      (void) fprintf (stderr,"assume stdout for output\n");
  1610. X    }
  1611. X    break;
  1612. X      case 'e':
  1613. X    if  ((narg+1) >= argc )
  1614. X      fatal((stderr,"missing argument to %s option",cp));
  1615. X    narg++ ;
  1616. X
  1617. X    i=0;
  1618. X    nb_move_to_dsp = 0;
  1619. X    move_to_display[nb_move_to_dsp] = 0;
  1620. X    while (isdigit(argv[narg][i])) {
  1621. X      move_to_display[nb_move_to_dsp] =
  1622. X        ((int) argv[narg][i] - (int) '0')
  1623. X          + move_to_display[nb_move_to_dsp] * 10;
  1624. X      i++;
  1625. X    }
  1626. X    nb_move_to_dsp++;
  1627. X    stop_at_display = TRUE;
  1628. X    break;
  1629. X      case 'c':
  1630. X    if  ((narg+1) >= argc )
  1631. X      fatal((stderr,"missing argument to %s option",cp));
  1632. X    narg++ ;
  1633. X
  1634. X    i=0;
  1635. X    while (isdigit(argv[narg][i])) {
  1636. X      move_to_display[nb_move_to_dsp] = 0;
  1637. X      while (isdigit(argv[narg][i])) {
  1638. X        move_to_display[nb_move_to_dsp] =
  1639. X          ((int) argv[narg][i] - (int) '0')
  1640. X          + move_to_display[nb_move_to_dsp] * 10;
  1641. X        i++;
  1642. X      }
  1643. X      nb_move_to_dsp++;
  1644. X
  1645. X      if (nb_move_to_dsp > NB_MOVE_TO_DISP)
  1646. X        fatal((stderr,"max. number of move to display exceeded"));
  1647. X
  1648. X      /* process next number */
  1649. X      if (argv[narg][i] == ',')
  1650. X        i++;
  1651. X    }
  1652. X    break;
  1653. X      case 'a': /* algebraic output */
  1654. X    dr->output_move_format = ALGEBRAIC;
  1655. X    break;
  1656. X      case 's':  /* shortened output */
  1657. X    dr->output_move_format = SHORTENED;
  1658. X    break;
  1659. X      case 'b': /* display only the board, no move */
  1660. X    dr->only_board = TRUE;
  1661. X    break;
  1662. X      case 'd': /* output driver */
  1663. X    if  ((narg+1) >= argc )
  1664. X      fatal((stderr,"missing argument to %s option",cp));
  1665. X    narg++ ;
  1666. X    driver = find_keyword(t_output, NB_DRIVER, DEFAULT_DRIVER,
  1667. X                  argv[narg],TRUE);
  1668. X    break;
  1669. X      case 'i': /* no headers */
  1670. X    dr->print_headers = FALSE;
  1671. X    break;
  1672. X      case 'v': /* print version */
  1673. X    /* this already done, so exit() */
  1674. X    exit(0);
  1675. X    break;
  1676. X      case 'h': /* help file */
  1677. X    (void) strcpy(chaine,LIB_DIR);
  1678. X        if ((fhelp = fopen(strcat(chaine,HELP_FILE),"r")) == NULL)
  1679. X          fatal((stderr,"Can't find help file.\n"));
  1680. X        else {
  1681. X          while ((c = getc(fhelp)) != EOF)
  1682. X            (void) fputc(c,stderr);
  1683. X          (void) fclose(fhelp);
  1684. X      exit(0);
  1685. X        }
  1686. X         break;
  1687. X      default:
  1688. X    error((stderr,"unknown command line options %s\n",cp));
  1689. X    break;
  1690. X      }
  1691. X      break;
  1692. X    default: /* assume this is the input file */
  1693. X      if ((infile = fopen (cp,"r")) == NULL)
  1694. X    fatal((stderr,"can't open %s input file\n",cp));
  1695. X    }
  1696. X    narg++;
  1697. X  } /* process next arg */
  1698. X  return(argc);
  1699. X}
  1700. X
  1701. X#ifdef __STDC__
  1702. Xvoid close_files(void)
  1703. X#else
  1704. Xvoid close_files()
  1705. X#endif
  1706. X{
  1707. X  if (!((infile == stdin)||(infile == NULL)))
  1708. X    (void) fclose(infile);
  1709. X  if (dr->outfile != stdout )
  1710. X    (void) fclose(dr->outfile);
  1711. X}
  1712. X
  1713. X#ifdef __STDC__
  1714. Xint associe_traduction (char **table, int language)
  1715. X#else
  1716. Xint associe_traduction (table, language)
  1717. Xchar ** table;
  1718. Xint language ;
  1719. X#endif
  1720. X{
  1721. X  if (language < 0 || (language >= NBLANGUAGES))
  1722. X    error((stderr,"unknown language\n"));
  1723. X  else
  1724. X    *table = c_language[language];
  1725. X  return(language);
  1726. X}
  1727. X
  1728. X#ifdef __STDC__
  1729. Xstatic void print_all_play(play *p)
  1730. X#else
  1731. Xstatic void print_all_play(p)
  1732. Xplay *p;
  1733. X#endif
  1734. X{ 
  1735. X  depl *d;
  1736. X  d = p->chain;
  1737. X  while (d->next != NULL){
  1738. X    d = d->next;
  1739. X    output_move(dr,d);
  1740. X  }
  1741. X}
  1742. X
  1743. X/* ------------- main --------------------- */
  1744. X
  1745. X#ifdef __STDC__
  1746. Xvoid main(int argc,char *argv[])
  1747. X#else
  1748. Xint main(argc,argv)
  1749. X     int argc;
  1750. X     char * argv[];
  1751. X#endif
  1752. X{
  1753. X  (void) fprintf(stderr,"%s\n",version_string);
  1754. X  
  1755. X  /* allocation of driver descriptor */
  1756. X  dr = new_driver();
  1757. X
  1758. X  /* default configuration */
  1759. X  init_driver(dr,DEFAULT_DRIVER);
  1760. X  (void) associe_traduction(&in_table,  DEFAULT_INPUT_LANGUAGE );
  1761. X  (void) associe_traduction(&(dr->out_table), DEFAULT_OUTPUT_LANGUAGE);
  1762. X
  1763. X  (void) parse_options(argc,argv);
  1764. X
  1765. X  (void) associe_traduction (&in_table, in_language);
  1766. X  (void) associe_traduction (&(dr->out_table), out_language);
  1767. X
  1768. X  /* assoc driver */
  1769. X  init_driver(dr,driver);
  1770. X
  1771. X  configuring = FALSE;
  1772. X  configside = VOID;
  1773. X
  1774. X  /* initialise output file */
  1775. X  output_init(dr);
  1776. X
  1777. X  if (error_flag)
  1778. X    fatal((stderr,"too many errors"));
  1779. X
  1780. X  /* allocation of board descriptor */
  1781. X  tos = new_board();
  1782. X  init_board(tos);
  1783. X
  1784. X  /* allocation of move descriptor */
  1785. X  m = new_move();
  1786. X  m->type = VOID ;
  1787. X  /*init_move(m);*/
  1788. X  
  1789. X  /* allocation of the play descriptor */
  1790. X  theplay = (play *) malloc (sizeof(play)) ;
  1791. X  theplay->initial = tos ;
  1792. X  theplay->chain   = m ;
  1793. X  movecount = 1;
  1794. X
  1795. X  /* main analysis routine */
  1796. X  yyin = infile ;
  1797. X  yyout = stderr ;
  1798. X
  1799. X  /*init_parse(m); */
  1800. X  yylex();
  1801. X
  1802. X  if ((count == 0) && !error_flag)
  1803. X    output_board(dr,tos);
  1804. X
  1805. X  if (error_flag) {
  1806. X    error((stderr,"last valid position:\n"));
  1807. X    output_board(dr,tos);
  1808. X    fatal((stderr,"too many errors"));
  1809. X  }
  1810. X      
  1811. X  /* terminates output files */
  1812. X  output_end(dr);
  1813. X
  1814. X  /* close files */
  1815. X  close_files();
  1816. X
  1817. X  /* exit properly */
  1818. X#ifdef __STDC__
  1819. X#else
  1820. X  exit(0);
  1821. X#endif
  1822. X}
  1823. END_OF_FILE
  1824. if test 40751 -ne `wc -c <'notation.c'`; then
  1825.     echo shar: \"'notation.c'\" unpacked with wrong size!
  1826. fi
  1827. # end of 'notation.c'
  1828. fi
  1829. echo shar: End of archive 4 \(of 4\).
  1830. cp /dev/null ark4isdone
  1831. MISSING=""
  1832. for I in 1 2 3 4 ; do
  1833.     if test ! -f ark${I}isdone ; then
  1834.     MISSING="${MISSING} ${I}"
  1835.     fi
  1836. done
  1837. if test "${MISSING}" = "" ; then
  1838.     echo You have unpacked all 4 archives.
  1839.     rm -f ark[1-9]isdone
  1840. else
  1841.     echo You still need to unpack the following archives:
  1842.     echo "        " ${MISSING}
  1843. fi
  1844. ##  End of shell archive.
  1845. exit 0
  1846.  
  1847. --
  1848. Henry Thomas - IRISA          - E-mail: Henry.Thomas@irisa.fr 
  1849. Campus Universitaire de Beaulieu - Phone: (+33)99 36 20 00 +549  
  1850. 35042 RENNES CEDEX FRANCE      - Fax: (+33)99 38 38 32 Telex: UNIRISA 950473F
  1851. Telex Atlas X400: /X121=842950473/@atlas.fr, Fax:/X121=200099383832/@atlas.fr
  1852. --
  1853.  
  1854. exit 0 # Just in case...
  1855. -- 
  1856. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1857. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1858. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1859. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1860.